package day6.blocking_queue_impl;
/**
 * 实现一个阻塞队列
 */
public class MyArrayBlockingQueue {

    private long[] array;
    private int frontIndex; // 永远在队列的第一个元素位置
    private int rearIndex;  // 永远在队列的最后一个的下一个位置
    private int size; // 元素的个数

    public MyArrayBlockingQueue(int capacity) {
        array = new long[capacity];
        // 定义初始状态
        frontIndex = 0;
        rearIndex = 0;
        size = 0;
    }

    // 加锁线程安全
    public synchronized void put(long e) throws InterruptedException {
        // 先判断是否满
        while(size == array.length){
            // TODO: 满
            this.wait();
            /**
             * 为什么使用while而不是if?
             *   因为在多对多的情况下，该线程被唤醒后不一定能抢到锁。
             *   当自己抢到锁后就不一定满足"队列未满"的条件，有可能已经被之前抢到锁的线程填满了。
             *   如果是if，就会在抢到锁后直接执行后面的代码，不会再次判断。所以需要while语句多次判断。
             */
        }

        // 还没有满
        array[rearIndex] = e;
        // 因为是循环队列，所以不能简单的++操作
        rearIndex = (rearIndex + 1) % array.length;
        size ++;
        this.notifyAll();
        /**
         * 为什么使用notifyAll，而不是notify？
         *   如果只有一个消费者和一个生产者的话，消费者唤醒的一定是生产者，生产者唤醒的一定是消费者。
         *   但如果是多对多的场景下，就有可能出现消费者唤醒消费者的情况(因为notify是随机的)。
         *   最坏的情况下，多个消费者唤醒的都是消费者，而所有生产者都在wait中，出现死锁的情况。
         */
    }

    public synchronized long take() throws InterruptedException {
        // 先判断是否为空
        while(size == 0){
            // TODO: 空
            this.wait();
        }

        // 不空
        long ret = array[frontIndex];
        frontIndex = (frontIndex + 1) % array.length;
        size --;
        this.notifyAll();
        return ret;
    }
}
